home *** CD-ROM | disk | FTP | other *** search
/ Business Shareware / Business Shareware.iso / start / disk / st2dos10 / st2dos.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-04-17  |  6.2 KB  |  224 lines
  1. /*
  2.     ST2DOS - Make Atari ST written disks readable under DOS
  3.     Module st2dos.c
  4.  
  5.     Copyright (C) 1993 Arno Schaefer
  6.  
  7.     This program is free software; you can redistribute it and/or modify
  8.     it under the terms of the GNU General Public License as published by
  9.     the Free Software Foundation; either version 1, or (at your option)
  10.     any later version.
  11.  
  12.     This program is distributed in the hope that it will be useful,
  13.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.     GNU General Public License for more details.
  16.  
  17.     You should have received a copy of the GNU General Public License
  18.     along with this program; if not, write to the Free Software
  19.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20. */
  21.  
  22. #include <stdio.h>
  23. #include <dos.h>
  24. #include <bios.h>
  25. #include <alloc.h>
  26.  
  27. typedef unsigned char byte;
  28. typedef unsigned int word;
  29. typedef unsigned long dword;
  30.  
  31. typedef enum {false,true} boolean;
  32.  
  33. #define DISK_INT 0x13
  34.  
  35. #define RESET_DISK 0
  36. #define READ_SECTOR 2
  37. #define WRITE_SECTOR 3
  38. #define VERIFY_SECTOR 4
  39. #define GET_DISK_TYPE 0x15
  40.  
  41. /* ----------------------------------------------------------------------- */
  42. /* Copyright notice and version number                                     */
  43. /* ----------------------------------------------------------------------- */
  44.  
  45. void notice (void)
  46. {
  47.     printf ("\nST2DOS version 1.0, Copyright (C) 1993 Arno Schaefer\n");
  48.     printf ("Makes Atari ST written disks readable under DOS\n");
  49.     printf ("ST2DOS comes with ABSOLUTELY NO WARRANTY, see file COPYING for details\n");
  50.     printf ("This is free software, and you are welcome to redistribute it\n");
  51.     printf ("under certain conditions; again see file COPYING for details.\n\n");
  52. }
  53.  
  54. /* ----------------------------------------------------------------------- */
  55. /* Error Handling                                                          */
  56. /* ----------------------------------------------------------------------- */
  57.  
  58. int getx (void)
  59. {
  60.     int character = getch();
  61.     if (character == 3)
  62.     {
  63.         printf ("\n");
  64.         exit (0);
  65.     }
  66.     return (character);
  67. }
  68.  
  69. void error (char *message)
  70. {
  71.     fprintf (stderr,"\nError: %s!\n",message);
  72.     exit (-1);
  73. }
  74.  
  75. void warning (char *message)
  76. {
  77.     fprintf (stderr,"\nWarning: %s\n",message);
  78.     fprintf (stderr,"Press any key\n");
  79.     getx();
  80. }
  81.  
  82. /* ----------------------------------------------------------------------- */
  83. /* BIOS calls                                                              */
  84. /* ----------------------------------------------------------------------- */
  85.  
  86. int reset_drive (int drive_number)
  87. {
  88.     union REGS regs;
  89.  
  90.     regs.h.ah = RESET_DISK;
  91.     regs.h.dl = drive_number;
  92.     int86 (DISK_INT,®s,®s);
  93.     if (regs.x.cflag) return (-1);
  94.     return 0;
  95. }
  96.  
  97. int get_disk_type (int drive_number)
  98. {
  99.     union REGS regs;
  100.     regs.h.ah = GET_DISK_TYPE;
  101.     regs.h.dl = drive_number;
  102.     int86 (DISK_INT,®s,®s);
  103.     if (regs.x.cflag) return 0;
  104.     return (regs.h.ah);            /* disk type */
  105. }
  106.  
  107. /* ----------------------------------------------------------------------- */
  108. /* read / write sectors                                                    */
  109. /* ----------------------------------------------------------------------- */
  110.  
  111. int read_sector (int drive_number,dword head,dword cylinder,dword sector,byte *buffer)
  112. {
  113.     int i;
  114.     boolean done=false;
  115.     for (i=0;i<3;i++)
  116.     {
  117.         if (!biosdisk (READ_SECTOR,drive_number,head,cylinder,sector,1,buffer))
  118.         {
  119.             done=true;
  120.             break;
  121.         }
  122.         reset_drive(drive_number);
  123.     }
  124.     if (!done) return (-1);
  125.     return 0;
  126. }
  127.  
  128. int verify_sector (int drive_number,dword head,dword cylinder,dword sector,byte *buffer)
  129. {
  130.     if (biosdisk (VERIFY_SECTOR,drive_number,head,cylinder,sector,1,buffer)) return (-1);
  131.     return 0;
  132. }
  133.  
  134. int write_sector (int drive_number,dword head,dword cylinder,dword sector,byte *buffer)
  135. {
  136.     int i;
  137.     boolean done=false;
  138.     for (i=0;i<3;i++)
  139.     {
  140.         if (!biosdisk (WRITE_SECTOR,drive_number,head,cylinder,sector,1,buffer))
  141.         {
  142.             done=true;
  143.             break;
  144.         }
  145.         reset_drive(drive_number);
  146.     }
  147.     if (!done) return (-1);
  148.     return (verify_sector (drive_number,head,cylinder,sector,buffer));
  149. }
  150.  
  151. /* ----------------------------------------------------------------------- */
  152. /* Main                                                                    */
  153. /* ----------------------------------------------------------------------- */
  154.  
  155. void main (void)
  156. {
  157.     int drive_number = 0;
  158.     byte media_byte;
  159.     byte buffer[512];
  160.  
  161.     int sides,sectors_per_track,sectors_per_fat;
  162.     int fat2side,fat2track,fat2sector;
  163.  
  164.     notice ();
  165.  
  166.     if (get_disk_type (1))
  167.     {
  168.         int character='x';
  169.         printf ("Which drive (A/B): ");
  170.         while ((character != 'a') && (character != 'b')) character = getx();
  171.         printf ("%c\n\n",character);
  172.         drive_number = character - 'a';
  173.     }
  174.  
  175.     while (true)
  176.     {
  177.         printf ("Insert Disk to be converted and press any key\n");
  178.  
  179.         getx();
  180.  
  181.         if (read_sector (drive_number,0,0,1,buffer))
  182.             error ("Error reading Bootsector");
  183.  
  184.         sectors_per_fat = buffer[22];
  185.         sectors_per_track = buffer[24];
  186.         sides = buffer[26];
  187.  
  188.         if (sectors_per_track > 12)
  189.         {
  190.             warning ("Can't convert High Density Disks");
  191.             continue;
  192.         }
  193.  
  194.         if (sides == 1) media_byte = 0xf8;
  195.         else if (sides == 2) media_byte = 0xf9;
  196.         else error ("Invalid Bootsector");
  197.  
  198.         buffer[0] = 0xeb;
  199.         buffer[1] = 0x3c;
  200.         buffer[2] = 0x90;
  201.  
  202.         buffer[21] = media_byte;
  203.  
  204.         if (write_sector (drive_number,0,0,1,buffer))
  205.             error ("Error writing Bootsector");
  206.  
  207.         if (read_sector (drive_number,0,0,2,buffer))
  208.             error ("Error reading FAT 1");
  209.         buffer[0] = media_byte;
  210.         if (write_sector (drive_number,0,0,2,buffer))
  211.             error ("Error writing FAT 1");
  212.  
  213.         fat2track = (1 + sectors_per_fat) / (sides * sectors_per_track);
  214.         fat2side = (1 + sectors_per_fat - (fat2track * sides * sectors_per_track)) / sectors_per_track;
  215.         fat2sector = 1 + sectors_per_fat - (fat2track * sides * sectors_per_track) - (fat2side * sectors_per_track) + 1;
  216.  
  217.         if (read_sector (drive_number,fat2side,fat2track,fat2sector,buffer))
  218.             error ("Error reading FAT 2");
  219.         buffer[0] = media_byte;
  220.         if (write_sector (drive_number,fat2side,fat2track,fat2sector,buffer))
  221.             error ("Error writing FAT 2");
  222.     }
  223. }
  224.